﻿using System.Linq;

namespace MyLambda
{
    internal class Program
    {
        static void Main(string[] args)
        {
            try
            {
                //1.Lambada前世今生
                //2.匿名类
                //3.扩展方法
                //4.linq to object
                //5.linq原理
                //6.迭代器yield
                //7.linq To everything

                //一、Lambada前世今生 
                //lambad: 形如  c=> { }
                {

                    var list = new List<int>();
                    _ = list.Where(c => c == 1);  //按照条件做过滤~·

                    new LambdaShow().Show();
                }
                //二、匿名类

                {
                    Console.WriteLine("*****************普通类**************");
                    //普通类
                    Student student = new Student()
                    {
                        Id = 1,
                        Name = "夕林吹雪",
                        Age = 25,
                        ClassId = 2
                    };
                    student.Study();
                    student.StudyQt();

                    student.Age = 25;

                    Console.WriteLine(student.Id);
                    Console.WriteLine(student.Name);

                    Console.WriteLine("*****************匿名类**************");
                    object student1 = new Student() //C#中的所有类型都是集成object
                    {
                        Id = 1,
                        Name = "夕林吹雪",
                        Age = 25,
                        ClassId = 2
                    };

                    //匿名类--new 一个对象的手，也不需要名称了
                    object model = new//3.0      //匿名类  看不到了类名称；  
                    {
                        Id = 1,
                        Name = "夕林吹雪",
                        Age = 25,
                        ClassId = 2
                    };

                    //model.Id = 123;  不允许

                    //无法访问属性值
                    // Console.WriteLine(model.Id); //为什么？因为C#是强类型语言（编译时决定类型），object是在编译时确定类型； 因为Object没有这个属性； 
                    //Console.WriteLine(model.Name);

                    //dynamic避开编译器检查   .NETFramework(4.0)
                    //(动态类型)，可以避开编译器的检查
                    dynamic dModel = new//  dynamic可以避开编译器的检查,运行时检查，运行时决定类型
                    {
                        Id = 1,
                        Name = "夕林吹雪",
                        Age = 25,
                        ClassId = 2
                    };

                    // dModel.Id = 134; //不允许

                    Console.WriteLine(dModel.Id);
                    Console.WriteLine(dModel.Name);
                    // Console.WriteLine(dModel.Js);// 可以乱取、会报异常

                    //关键字： var 弱类型
                    //var 语法糖 (编译器提供的便捷功能)  可以理解为弱类型；不确定类型；
                    Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
                    var model1 = new  //1.不能声明方法，必须在声明的时候，就给定匿名类的属性初始值   2.不能给属性重新赋值  
                    {
                        Id = 1,
                        Name = "Nochat",
                        Age = 25,
                        ClassId = 2
                    };

                    //model1.Id = 345; //不允许 2.不能给属性重新赋值  


                    Console.WriteLine(model1.Id); //var 定义的匿名类，可以访问存在的属性值；
                    Console.WriteLine(model1.Name);
                    // Console.WriteLine(model1.Js);  //不允许----取值，必须是内部包含的元素；
                    // model1.Id = 3; // 属性是只读，不能设置值；


                    Console.WriteLine("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
                    int i2 = 2;
                    var i1 = 1;//var就是个语法糖，由编译器自动推算  


                    var s = "Richard";


                    //var strnull = null; //编译器不允许； 
                    // var aa;//var声明的变量必须初始化，必须能推算出类型
                    //也不允许作为方法的参数类型 
                    ////1 var 配合匿名类型使用
                    ////2 var 偷懒，复杂类型的使用 
                    ////3 在不知道具体是什么类型的时候就可以使用var 来声明； 
                    //缺陷：个人认为，在代码阅读的时候不是很方便；
                    //建议大家在写代码的时候，尽量明确类型； 
                    var i = 13;
                    var j = "";
                    var mode = new { };

                    //现在21:01,中场休息5分钟，21:06继续，期间老师不说话了~~ 休息&WC
                    //一切正常的 刷个1  
                }

                ////三、扩展方法
                ////1.扩展：扩充--让功能变的更加强大--让不存在功能存在 ---新增逻辑处理
                ////2.已经存在方法，正常调用，扩展的东西不影响已经存在的方法
                ////3.如果需求变更，需要支持另外一个新的功能；
                {
                    Student student = new Student()
                    {
                        Id = 123,
                        Name = "打武松的小老虎",
                        Age = 25,
                        ClassId = 1
                    };
                    student.Study();//调用方法
                    student.StudyQt();

                    //如果要增加一个需求---学习嵌入式； 直接增加方法
                    //1.对于原有的类--修改结构
                    student.StudyEmbedded();
                    //2.期望：既可以增加新的功能，历史代码不变；直接增加类，在新的类中去完成；

                    Console.WriteLine("新增类新增方法的实现~~");
                    MethodExtension.StudyEmbedded(student);
                    student.StudyEmbedded();  //静态方法的调用-- 可以像实例方法一样去调用；

                    //不用修改原有的任何类中的类，可以新增功能；
                    //有哪些场景？
                    //1.有新的需求来的时候---扩展方法---保证历史代码稳定；
                    //2.要引用第三方的DLLL库（提供的功能不完善，我们自己需要升级下----dll,不能修改原有的代码）扩展方法
                    //3.封装一个帮助类库,字符串的截取；

                    string str = "有新的需求来的时候---扩展方法---保证历史代码问题";
                    string sResult1 = str.Sub(11);
                    string sResult2 = str.Sub(20);
                    string sResult3 = str.Sub();
                    //4.asp.net core 中，到处都是扩展方法----框架的设计----最小化设计； 提供一个最基本的，最最最简单的功能，提供给使用方；
                    //   在使用的时候， 如果想要增强功能，可以扩展~~  好处：1. 尽可能简化代码   2.灵活分配，需要就扩展什么；按需扩展，不会有代码冗余；


                    //学习----看书,   看视频学习，  上网学习 ，  跟Richard的直播学习。。

                    //可以为任意类型写扩展方法吗？ 注意：
                    //扩展object 类型
                    object o = "object 类型";
                    o.SubObj();

                    int i = 1;
                    i.SubObj();//可以

                    string sr = "你好";
                    sr.SubObj();


                    str.SubGeneric();
                    student.SubGeneric(); //隐患

                    //总结：
                    //1. 扩展的类型具有继承性，扩展父类，所有子类都拥有这个功能；扩展的功能可能不使用一些具体的类型；但是仍然可以调用；可能会造成一些类型功能的污染；----慎用
                    //2.  不建议扩展object，也不是很建议大家去泛型扩展；



                    Console.WriteLine("****************************");
                }
                ////四、Linq to Object
                //{
                //    //List<Student> studentlist = new List<Student>(); 
                //    //studentlist.Where(c => c.Id > 0);//表示查询集合中Id大于0的数据
                //    //new LinqShow().Show(); 
                //    //studentlist.GroupBy()
                //}
                ////五、Linq原理:笔记详解--LinqPrinciple 
                //{
                //    //new LinqPrinciple().Show();
                //}
                ////六、常见Ling语句
                //{
                //    new LinqShow().Show();
                //}
                ////七、Linq to Everything 笔记详解--LinqPrinciple 
                //{

                //}

                Console.ReadKey();

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}
